#!/usr/bin/python3
# _*_ coding: utf-8 _*_
#
# Copyright (C) 2024 - 2024 heihieyouheihei, Inc. All Rights Reserved 
#
# @Time    : 2024/9/23 11:53
# @Author  : Yuyun
# @File    : leetcode_112_路径总和.py
# @IDE     : PyCharm
"""
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。
判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。
如果存在，返回 true ；否则，返回 false 。
叶子节点 是指没有子节点的节点

示例 1：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。
示例 2：
输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。
示例 3：
输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：
树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000
"""
from collections import deque
class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
"""
DFS:
    前序遍历；中-左-右
    将路径节点、targetSum作为参数传入DFS函数
    处理中节点：当路径节点总和 == targetSum 且当前节点为叶子节点时，找到路径
    处理左节点：DFS遍历左节点
    处理右节点：DFS遍历右节点
"""
class Solution:
    def build_tree(self, levelorder=[]):
        length = len(levelorder)
        if length == 0:
            return None
        root = TreeNode(levelorder[0])
        queue = [root]
        i = 1
        while queue and i < length:
            node = queue.pop(0)
            if levelorder[i] != None:
                node.left = TreeNode(levelorder[i])
                queue.append(node.left)
            i += 1
            if i < length and levelorder[i] != None:
                node.right = TreeNode(levelorder[i])
                queue.append(node.right)
            i += 1
        return root
    def dfs(self,root, targetSum, res, tmpSum):
        #   树为空，直接返回False
        if not root:
            res[0] = False
        #   找到叶子节点，且路径和 = targetSum
        if sum(tmpSum) == targetSum and not root.left and not root.right:
            res[0] = True
        if root.left:
            self.dfs(root.left, targetSum, res, tmpSum + [root.left.val])
        if root.right:
            self.dfs(root.right, targetSum, res, tmpSum + [root.right.val])
    """
    BFS:
        使用队列保存每个节点路径和
        若存在一个节点恰好是叶子节点，且路径和 = targetSum，找到路径
        
    """

    def bfs(self, root, res, targetSum):
        if not root:
            return res[0]
        queue = [(root, root.val)]
        while queue:
            node, path = queue.pop(0)
            if not node.left and not node.right and path == targetSum:
                res[0] = True
                return res[0]   #   找到即返回，减少遍历次数
            if node.left:
                queue.append((node.left, path + node.left.val))
            if node.right:
                queue.append((node.right, path + node.right.val))
        return res[0]

if __name__ == '__main__':
    try:
        nums = eval(input())
        solution =Solution()
        root = solution.build_tree(nums)
        targetSum = int(input())
        res = [False]
        if root == None:
            print(False)
        else:
            # solution.dfs(root, targetSum, res, [root.val])
            solution.bfs(root, res, targetSum)
            print(res[0])
    except Exception as e:
        print(e)